<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>SearchableRDD - it.agilelab.bigdata.spark.search.SearchableRDD</title>
          <meta name="description" content="SearchableRDD - it.agilelab.bigdata.spark.search.SearchableRDD" />
          <meta name="keywords" content="SearchableRDD it.agilelab.bigdata.spark.search.SearchableRDD" />
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link href="../../../../../lib/template.css" media="screen" type="text/css" rel="stylesheet" />
      <link href="../../../../../lib/diagrams.css" media="screen" type="text/css" rel="stylesheet" id="diagrams-css" />
      <script type="text/javascript">
         if(top === self) {
            var url = '../../../../../index.html';
            var hash = 'it.agilelab.bigdata.spark.search.SearchableRDD';
            var anchor = window.location.hash;
            var anchor_opt = '';
            if (anchor.length >= 1)
              anchor_opt = '@' + anchor.substring(1);
            window.location.href = url + '#' + hash + anchor_opt;
         }
   	  </script>
    
        </head>
        <body class="type">
      <div id="definition">
        <a href="SearchableRDD$.html" title="Go to companion"><img src="../../../../../lib/class_to_object_big.png" /></a>
        <p id="owner"><a href="../../../../package.html" class="extype" name="it">it</a>.<a href="../../../package.html" class="extype" name="it.agilelab">agilelab</a>.<a href="../../package.html" class="extype" name="it.agilelab.bigdata">bigdata</a>.<a href="../package.html" class="extype" name="it.agilelab.bigdata.spark">spark</a>.<a href="package.html" class="extype" name="it.agilelab.bigdata.spark.search">search</a></p>
        <h1><a href="SearchableRDD$.html" title="Go to companion">SearchableRDD</a></h1>
      </div>

      <h4 id="signature" class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">class</span>
      </span>
      <span class="symbol">
        <span class="name">SearchableRDD</span><span class="tparams">[<span name="T">T</span>]</span><span class="result"> extends <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      
          <div id="comment" class="fullcommenttop"><div class="comment cmt"><p>Indexed RDD that provides search functionality.</p><h4>Principle of operation</h4><p>The elements of the input RDD must implement the <a href="Indexable.html" class="extype" name="it.agilelab.bigdata.spark.search.Indexable">Indexable</a> trait; an advanced mechanism
based on implicit conversion using code generation is available that supports common data
types and classes built from them, so no work at all is required in many cases; see <a href="Indexable.html" class="extype" name="it.agilelab.bigdata.spark.search.Indexable">Indexable</a>
for details.</p><p>For each partition of the input RDD, an <a href="IndexedPartition.html" class="extype" name="it.agilelab.bigdata.spark.search.IndexedPartition">IndexedPartition</a> is built, which contains both the
<a href="Index.html" class="extype" name="it.agilelab.bigdata.spark.search.Index">Index</a> for the data in the partition and the data itself.</p><p>Thus, the number of indices built is the same as the number of partitions of the input RDD; every
operation must interrogate all the indices, so the number of indices directly affects performance.</p><p>This means a compromise must be made between efficient operation and partition number/size; this
is an important concern as big partitions can easily wreak havoc and cause OOM errors, especially
during shuffles.</p><p>Work is underway to decouple the data partitioning from the indexes using different RDDs and/or
broadcast variables, in order to alleviate this problem.</p><h4>Queries</h4><p>The queries can either be of type <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a> or of type <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>. In the latter
case the way they are interpreted is implementation-dependent.</p><h4>Functionalities</h4><p>The functionalities provided are broadly separable in two categories:</p><ul><li><b>search</b></li><li><b>query join</b></li></ul><p><b>Search</b> functionalities are implemented with methods with <code>search</code> in their name, and are
of two kinds:</p><ul><li>those that return results directly, similar to a <code>collect()</code></li><li>those that return RDDs</li></ul><p>Obviously, the latter ones are much more suited when many queries are to be executed or when results
contain many and/or large elements.</p><p><b>Query join</b> functionalities allow the execution of a join operation on an RDD and a
SearchableRDD, in which the join predicate is a query which is built from each of the elements
of the other RDD and executed on the SearchableRDD.
The other RDD can be the SearchableRDD itself.</p><h4>Variations</h4><p>For methods of both functionalities, two variations are available:</p><ul><li><b>light</b></li><li><b>transformer</b> which returns the result of applying the provided transformer function to the results</li></ul><p><b>Light</b> variations are indicated by a <code>light</code> prefix to the corresponding base method. They
return <code>Long</code> ids instead of elements as results; this means that results use much less memory.</p><p><b>Transformer</b> variations specify an additional transformer function which is applied to the
elements; this allows the extraction of the relevant information from reults to be done as soon
as possible, again helping with memory usage.
</p></div><dl class="paramcmts block"><dt class="tparam">T</dt><dd class="cmt"><p>the type of the elements.</p></dd></dl><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>Some operations use zipWithUniqueId internally; as such, the same caveats
                       apply, namely that the assigned id is order-dependent. This means that
                       <b>the input RDD must be consistent upon reevaluation</b>, that is, the
                       elements inside the partitions and their ordering must be guaranteed to not
                       change between reevaluations. Otherwise, the behaviour is undefined.</p></span></dd><dt>See also</dt><dd><span class="cmt"><p><a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD@zipWithUniqueId():org.apache.spark.rdd.RDD[(T,Long)]" class="extype" target="_top">org.apache.spark.rdd.RDD#zipWithUniqueId</a>
</p></span></dd></dl><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Logging" class="extype" target="_top">Logging</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Serializable" class="extype" target="_top">Serializable</a>, <span class="extype" name="java.io.Serializable">Serializable</span>, <span class="extype" name="scala.AnyRef">AnyRef</span>, <span class="extype" name="scala.Any">Any</span></div>
        </div><div class="toggleContainer block">
          <span class="toggle">Known Subclasses</span>
          <div class="subClasses hiddenContent"><a href="impl/BroadcastIndexLuceneRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.impl.BroadcastIndexLuceneRDD">BroadcastIndexLuceneRDD</a>, <a href="impl/DistributedIndexLuceneRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.impl.DistributedIndexLuceneRDD">DistributedIndexLuceneRDD</a>, <a href="impl/PartitionsIndexLuceneRDD.html" class="extype" name="it.agilelab.bigdata.spark.search.impl.PartitionsIndexLuceneRDD">PartitionsIndexLuceneRDD</a></div>
        </div></div>
        

      <div id="mbrsel">
        <div id="textfilter"><span class="pre"></span><span class="input"><input id="mbrsel-input" type="text" accesskey="/" /></span><span class="post"></span></div>
        <div id="order">
              <span class="filtertype">Ordering</span>
              <ol>
                <li class="group out"><span>Grouped</span></li>
                <li class="alpha in"><span>Alphabetic</span></li>
                <li class="inherit out"><span>By inheritance</span></li>
              </ol>
            </div>
        <div id="ancestors">
                <span class="filtertype">Inherited<br />
                </span>
                <ol id="linearization">
                  <li class="in" name="it.agilelab.bigdata.spark.search.SearchableRDD"><span>SearchableRDD</span></li><li class="in" name="org.apache.spark.rdd.RDD"><span>RDD</span></li><li class="in" name="org.apache.spark.Logging"><span>Logging</span></li><li class="in" name="scala.Serializable"><span>Serializable</span></li><li class="in" name="java.io.Serializable"><span>Serializable</span></li><li class="in" name="scala.AnyRef"><span>AnyRef</span></li><li class="in" name="scala.Any"><span>Any</span></li>
                </ol>
              </div><div id="ancestors">
            <span class="filtertype"></span>
            <ol>
              <li class="hideall out"><span>Hide All</span></li>
              <li class="showall in"><span>Show all</span></li>
            </ol>
            <a href="http://docs.scala-lang.org/overviews/scaladoc/usage.html#members" target="_blank">Learn more about member selection</a>
          </div>
        <div id="visbl">
            <span class="filtertype">Visibility</span>
            <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
          </div>
      </div>

      <div id="template">
        <div id="allMembers">
        <div id="constructors" class="members">
              <h3>Instance Constructors</h3>
              <ol><li name="it.agilelab.bigdata.spark.search.SearchableRDD#&lt;init&gt;" visbl="pub" data-isabs="false" fullComment="no" group="Ungrouped">
      <a id="&lt;init&gt;(_sc:org.apache.spark.SparkContext,deps:Seq[org.apache.spark.Dependency[_]])(implicitct:scala.reflect.ClassTag[T]):it.agilelab.bigdata.spark.search.SearchableRDD[T]"></a>
      <a id="&lt;init&gt;:SearchableRDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">new</span>
      </span>
      <span class="symbol">
        <span class="name">SearchableRDD</span><span class="params">(<span name="_sc">_sc: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.SparkContext" class="extype" target="_top">SparkContext</a></span>, <span name="deps">deps: <span class="extype" name="scala.Seq">Seq</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Dependency" class="extype" target="_top">Dependency</a>[_]]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ct">ct: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span>
      </span>
      </h4>
      <p class="shortcomment cmt"></p>
    </li></ol>
            </div>

        

        <div id="values" class="values members">
              <h3>Abstract Value Members</h3>
              <ol><li name="it.agilelab.bigdata.spark.search.SearchableRDD#aggregatingSearch" visbl="pub" data-isabs="true" fullComment="yes" group="Search">
      <a id="aggregatingSearch(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):Array[(T,Double)]"></a>
      <a id="aggregatingSearch(Query,Int,Int):Array[(T,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregatingSearch</span><span class="params">(<span name="query">query: <a href="Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>Array</code> of elements matching the <code>query</code> with their scores, returning at most
<code>maxHits</code> results.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>Array</code> of elements matching the <code>query</code> with their scores, returning at most
<code>maxHits</code> results.</p><p>Setting <code>maxHitsPerIndex</code> limits the size of intermediate results. It must be a positive value
between <code>1</code> and <code>maxHits</code> (both inclusive). The (internally handled) default is <code>maxHits</code>.</p><p>The resulting <code>Array</code> is produced by efficiently aggregating partial results in a tree-level
pattern.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>Setting the maximum number of intermediate results to be lower than
                            the maximum number of results can lead to good results not being
                            returned, especially with non-uniform data distributions.
</p></span></dd><dt>See also</dt><dd><span class="cmt"><p><a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD@treeAggregate[U](zeroValue:U)(seqOp:(U,T)=&gt;U,combOp:(U,U)=&gt;U,depth:Int)(implicitevidence$34:scala.reflect.ClassTag[U]):U" class="extype" target="_top">org.apache.spark.rdd.RDD#treeAggregate</a>
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#aggregatingSearchWithResultsTransformer" visbl="pub" data-isabs="true" fullComment="no" group="Search">
      <a id="aggregatingSearchWithResultsTransformer[V](query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):Array[(V,Double)]"></a>
      <a id="aggregatingSearchWithResultsTransformer[V](Query,Int,(T)⇒V,Int):Array[(V,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregatingSearchWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="query">query: <a href="Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.aggregatingSearchWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.aggregatingSearchWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but specifying a <code>transformer</code> function to be applied to the result elements.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#batchSearch" visbl="pub" data-isabs="true" fullComment="yes" group="Search">
      <a id="batchSearch(queries:Iterable[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(T,Double)])]"></a>
      <a id="batchSearch(Iterable[(Long,DslQuery)],Int,Int):RDD[(Long,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearch</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterable">Iterable</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>RDD</code> of elements matching the <code>queries</code>, returning at most <code>maxHits</code> results for
each query.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>RDD</code> of elements matching the <code>queries</code>, returning at most <code>maxHits</code> results for
each query.</p><p>The queries must be provided with a unique id for each query, as an <code>Iterator</code> of <code>(id, query)</code>
pairs. The results of each query are returned associated with this unique id as <code>(id, results)</code>
pairs in the returned RDD; each <code>results</code> is an <code>Array</code> of <code>(element, score)</code> pairs.</p><p>Setting <code>maxHitsPerIndex</code> limits the size of intermediate results. It must be a positive value
between <code>1</code> and <code>maxHits</code> (both inclusive). The (internally handled) default is <code>maxHits</code>.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>Setting the maximum number of intermediate results to be lower than
                            the maximum number of results can lead to good results not being
                            returned, especially with non-uniform data distributions.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#batchSearchRaw" visbl="pub" data-isabs="true" fullComment="no" group="Search">
      <a id="batchSearchRaw(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.RawQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(T,Double)])]"></a>
      <a id="batchSearchRaw(Iterator[(Long,RawQuery)],Int,Int):RDD[(Long,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearchRaw</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but uses <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#batchSearchRawWithResultsTransformer" visbl="pub" data-isabs="true" fullComment="no" group="Search">
      <a id="batchSearchRawWithResultsTransformer[V](queries:Iterator[(Long,it.agilelab.bigdata.spark.search.RawQuery)],maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(V,Double)])]"></a>
      <a id="batchSearchRawWithResultsTransformer[V](Iterator[(Long,RawQuery)],Int,(T)⇒V,Int):RDD[(Long,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearchRawWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.batchSearchRawWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.batchSearchRawWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer[V](queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,transformer:T=&gt;V,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,T=&gt;V,Int)</span>,
but uses <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#batchSearchWithResultsTransformer" visbl="pub" data-isabs="true" fullComment="no" group="Search">
      <a id="batchSearchWithResultsTransformer[V](queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(V,Double)])]"></a>
      <a id="batchSearchWithResultsTransformer[V](Iterator[(Long,DslQuery)],Int,(T)⇒V,Int):RDD[(Long,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">batchSearchWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.batchSearchWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.batchSearchWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but specifying a <code>transformer</code> function to be applied to the result elements.</p>
    </li><li name="org.apache.spark.rdd.RDD#compute" visbl="pub" data-isabs="true" fullComment="yes" group="Ungrouped">
      <a id="compute(split:org.apache.spark.Partition,context:org.apache.spark.TaskContext):Iterator[T]"></a>
      <a id="compute(Partition,TaskContext):Iterator[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">compute</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>, <span name="context">context: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.TaskContext" class="extype" target="_top">TaskContext</a></span>)</span><span class="result">: <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@DeveloperApi</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getDocumentCounts" visbl="pub" data-isabs="true" fullComment="yes" group="Ungrouped">
      <a id="getDocumentCounts:Map[String,Long]"></a>
      <a id="getDocumentCounts:Map[String,Long]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getDocumentCounts</span><span class="result">: <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the document counts for this SearchableRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the document counts for this SearchableRDD.
The key for the map is the field name; the value is the number of documents.
</p></div></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getElement" visbl="pub" data-isabs="true" fullComment="no" group="Ungrouped">
      <a id="getElement(id:Long):Option[T]"></a>
      <a id="getElement(Long):Option[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getElement</span><span class="params">(<span name="id">id: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the element of this <code>SearchableRDD</code> with corresponds to the provided <code>id</code>, if it exists.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getElements" visbl="pub" data-isabs="true" fullComment="no" group="Ungrouped">
      <a id="getElements(ids:Array[Long]):Array[(Long,Option[T])]"></a>
      <a id="getElements(Array[Long]):Array[(Long,Option[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getElements</span><span class="params">(<span name="ids">ids: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#getElement(id:Long):Option[T]" class="extmbr" name="it.agilelab.bigdata.spark.search.SearchableRDD#getElement">getElement(Long)</a>, but for an <code>Array</code> of ids.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getIndicesInfo" visbl="pub" data-isabs="true" fullComment="no" group="Ungrouped">
      <a id="getIndicesInfo:it.agilelab.bigdata.spark.search.IndicesInfo"></a>
      <a id="getIndicesInfo:IndicesInfo"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getIndicesInfo</span><span class="result">: <a href="IndicesInfo.html" class="extype" name="it.agilelab.bigdata.spark.search.IndicesInfo">IndicesInfo</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns information about the indices.</p>
    </li><li name="org.apache.spark.rdd.RDD#getPartitions" visbl="prt" data-isabs="true" fullComment="yes" group="Ungrouped">
      <a id="getPartitions:Array[org.apache.spark.Partition]"></a>
      <a id="getPartitions:Array[Partition]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getPartitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getTermCounts" visbl="pub" data-isabs="true" fullComment="yes" group="Ungrouped">
      <a id="getTermCounts:Map[String,Map[String,Long]]"></a>
      <a id="getTermCounts:Map[String,Map[String,Long]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getTermCounts</span><span class="result">: <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the terms counts for this SearchableRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the terms counts for this SearchableRDD.
The key for the first map is the field name; the one for the second map is the term; the value is the number of
occurrences of the term in that field across all documents.
</p></div></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightAggregatingSearch" visbl="pub" data-isabs="true" fullComment="yes" group="Search">
      <a id="lightAggregatingSearch(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):Array[(Long,Double)]"></a>
      <a id="lightAggregatingSearch(Query,Int,Int):Array[(Long,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightAggregatingSearch</span><span class="params">(<span name="query">query: <a href="Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="aggregatingSearchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">aggregatingSearch(Query,Int,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightBatchSearch" visbl="pub" data-isabs="true" fullComment="yes" group="Search">
      <a id="lightBatchSearch(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]"></a>
      <a id="lightBatchSearch(Iterator[(Long,DslQuery)],Int,Int):RDD[(Long,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightBatchSearch</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="batchSearchWithResultsTransformer(queries:Iterator[(Long,it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery)],maxHits:Int,maxHitsPerIndex:Int)*">batchSearch(Iterator[(Long,DslQuery)],Int,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightBatchSearchRaw" visbl="pub" data-isabs="true" fullComment="no" group="Search">
      <a id="lightBatchSearchRaw(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.RawQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]"></a>
      <a id="lightBatchSearchRaw(Iterator[(Long,RawQuery)],Int,Int):RDD[(Long,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightBatchSearchRaw</span><span class="params">(<span name="queries">queries: <span class="extype" name="scala.Iterator">Iterator</span>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a>)]</span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#lightBatchSearch(queries:Iterator[(Long,it.agilelab.bigdata.spark.search.dsl.DslQuery)],maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Array[(Long,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.SearchableRDD#lightBatchSearch">lightBatchSearch(Iterator[(Long,DslQuery)],Int,Int)</a>,
but uses <a href="RawQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.RawQuery">RawQuery</a> type queries instead of <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">dsl.DslQuery</a>.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightQueryJoin" visbl="pub" data-isabs="true" fullComment="yes" group="QueryJoin">
      <a id="lightQueryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$5:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(Long,Double)])]"></a>
      <a id="lightQueryJoin[U](RDD[U],(U)⇒DslQuery,Int)(ClassTag[U]):RDD[(U,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightQueryJoin</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.lightQueryJoin.U">U</span>]</span>, <span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.lightQueryJoin.U">U</span>) ⇒ <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.lightQueryJoin.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.lightQueryJoin.U">U</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightSearch" visbl="pub" data-isabs="true" fullComment="yes" group="Search">
      <a id="lightSearch(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(Long,Double)]"></a>
      <a id="lightSearch(Query,Int,Int):RDD[(Long,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightSearch</span><span class="params">(<span name="query">query: <a href="Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but returns the ids of the resulting elements.</p><div class="fullcomment"><div class="comment cmt"><p>Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but returns the ids of the resulting elements.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>These ids are ephemeral, and can change between instances of this RDD;
                     they are only meaningful when used in combination with the same RDD that
                     provided them.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#queryJoin" visbl="pub" data-isabs="true" fullComment="yes" group="QueryJoin">
      <a id="queryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$1:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(T,Double)])]"></a>
      <a id="queryJoin[U](RDD[U],(U)⇒DslQuery,Int)(ClassTag[U]):RDD[(U,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoin</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoin.U">U</span>]</span>, <span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoin.U">U</span>) ⇒ <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoin.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoin.U">U</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>RDD</code> that contains the result of the query join between <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>RDD</code> that contains the result of the query join between <code>this</code> and <code>other</code>.</p><p>A query join is a join in which the predicate is a query. From each element of <code>other</code>, a query
is obtained by applying <code>queryGenerator</code>. Then each query is ran against <code>this</code>, and the
<code>maxHits</code> results produced are joined with the element originating the query.</p><p>Queries are executed in batches, with a batch for each partition of <code>other</code>.
</p></div></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#queryJoinWithResultsTransformer" visbl="pub" data-isabs="true" fullComment="no" group="QueryJoin">
      <a id="queryJoinWithResultsTransformer[U,V](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int,resultsTransformer:T=&gt;V)(implicitevidence$3:scala.reflect.ClassTag[U],implicitevidence$4:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[(U,Array[(V,Double)])]"></a>
      <a id="queryJoinWithResultsTransformer[U,V](RDD[U],(U)⇒DslQuery,Int,(T)⇒V)(ClassTag[U],ClassTag[V]):RDD[(U,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoinWithResultsTransformer</span><span class="tparams">[<span name="U">U</span>, <span name="V">V</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.U">U</span>]</span>, <span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.U">U</span>) ⇒ <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.U">U</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.U">U</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but specifying a <code>transformer</code> function to be applied to the result elements.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#search" visbl="pub" data-isabs="true" fullComment="yes" group="Search">
      <a id="search(query:it.agilelab.bigdata.spark.search.Query,maxHits:Int,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(T,Double)]"></a>
      <a id="search(Query,Int,Int):RDD[(T,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">search</span><span class="params">(<span name="query">query: <a href="Query.html" class="extype" name="it.agilelab.bigdata.spark.search.Query">Query</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns an <code>RDD</code> of elements matching the <code>query</code>, returning at most <code>maxHits</code> results.</p><div class="fullcomment"><div class="comment cmt"><p>Returns an <code>RDD</code> of elements matching the <code>query</code>, returning at most <code>maxHits</code> results.</p><p>Setting <code>maxHitsPerIndex</code> limits the size of intermediate results. It must be a positive value
between <code>1</code> and <code>maxHits</code> (both inclusive). The (internally handled) default is <code>maxHits</code>.
</p></div><dl class="attributes block"> <dt>Note</dt><dd><span class="cmt"><p>Setting the maximum number of intermediate results to be lower than
                            the maximum number of results can lead to good results not being
                            returned, especially with non-uniform data distributions.
</p></span></dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#searchWithResultsTransformer" visbl="pub" data-isabs="true" fullComment="no" group="Search">
      <a id="searchWithResultsTransformer[V](query:it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int,resultsTransformer:T=&gt;V,maxHitsPerIndex:Int):org.apache.spark.rdd.RDD[(V,Double)]"></a>
      <a id="searchWithResultsTransformer[V](DslQuery,Int,(T)⇒V,Int):RDD[(V,Double)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">abstract </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">searchWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="query">query: <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.searchWithResultsTransformer.V">V</span></span>, <span name="maxHitsPerIndex">maxHitsPerIndex: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a> = <span class="symbol"><span class="name"><a href="SearchableRDD$.html">sameAsMaxHits</a></span></span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.searchWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="searchWithResultsTransformer(query:it\.agilelab\.bigdata\.spark\.search\.Query,maxHits:Int,maxHitsPerIndex:Int)*">search(Query,Int,Int)</span>,
but specifying a <code>transformer</code> function to be applied to the result elements.</p>
    </li></ol>
            </div>

        <div id="values" class="values members">
              <h3>Concrete Value Members</h3>
              <ol><li name="scala.AnyRef#!=" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="!=(x$1:AnyRef):Boolean"></a>
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $bang$eq" class="name">!=</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.Any#!=" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="!=(x$1:Any):Boolean"></a>
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $bang$eq" class="name">!=</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.Any">Any</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="scala.AnyRef###" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="##():Int"></a>
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $hash$hash" class="name">##</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#++" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="++(other:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="++(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $plus$plus" class="name">++</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#==" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="==(x$1:AnyRef):Boolean"></a>
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $eq$eq" class="name">==</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.Any#==" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="==(x$1:Any):Boolean"></a>
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span title="gt4s: $eq$eq" class="name">==</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.Any">Any</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#aggregate" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="aggregate[U&lt;:&lt;?&gt;](zeroValue:&lt;?&gt;)(seqOp:&lt;?&gt;,combOp:&lt;?&gt;)(implicitevidence$33:&lt;?&gt;):U"></a>
      <a id="aggregate[U](U)((U,T)⇒U,(U,U)⇒U)(ClassTag[U]):U"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">aggregate</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="zeroValue">zeroValue: <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>)</span><span class="params">(<span name="seqOp">seqOp: (<span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>, <span name="combOp">combOp: (<span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>, <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span>]</span>)</span><span class="result">: <span class="extype" name="org.apache.spark.rdd.RDD.aggregate.U">U</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.Any#asInstanceOf" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="asInstanceOf[T0]:T0"></a>
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">asInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <span class="extype" name="scala.Any.asInstanceOf.T0">T0</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#cache" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="cache():RDD.this.type"></a>
      <a id="cache():SearchableRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">cache</span><span class="params">()</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#cartesian" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="cartesian[U](other:org.apache.spark.rdd.RDD[U])(implicitevidence$5:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(T,U)]"></a>
      <a id="cartesian[U](RDD[U])(ClassTag[U]):RDD[(T,U)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">cartesian</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.cartesian.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.cartesian.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.cartesian.U">U</span>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#checkpoint" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="checkpoint():Unit"></a>
      <a id="checkpoint():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">checkpoint</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#clearDependencies" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="clearDependencies():Unit"></a>
      <a id="clearDependencies():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clearDependencies</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#clone" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="clone():Object"></a>
      <a id="clone():AnyRef"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">clone</span><span class="params">()</span><span class="result">: <span class="extype" name="scala.AnyRef">AnyRef</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../java$lang.html" class="extype" name="java.lang">java.lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.CloneNotSupportedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#coalesce" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="coalesce(numPartitions:Int,shuffle:Boolean)(implicitord:Ordering[T]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="coalesce(Int,Boolean)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">coalesce</span><span class="params">(<span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="shuffle">shuffle: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#collect" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="collect[U](f:PartialFunction[T,U])(implicitevidence$32:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="collect[U](PartialFunction[T,U])(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collect</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.PartialFunction" class="extype" target="_top">PartialFunction</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.collect.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.collect.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.collect.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#collect" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="collect():Array[T]"></a>
      <a id="collect():Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">collect</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#context" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="context:org.apache.spark.SparkContext"></a>
      <a id="context:SparkContext"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">context</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.SparkContext" class="extype" target="_top">SparkContext</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#count" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="count():Long"></a>
      <a id="count():Long"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">count</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countApprox" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countApprox(timeout:&lt;?&gt;,confidence:&lt;?&gt;):org.apache.spark.partial.PartialResult[org.apache.spark.partial.BoundedDouble]"></a>
      <a id="countApprox(Long,Double):PartialResult[BoundedDouble]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countApprox</span><span class="params">(<span name="timeout">timeout: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>, <span name="confidence">confidence: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>)</span><span class="result">: <span class="extype" name="org.apache.spark.partial.PartialResult">PartialResult</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.partial.BoundedDouble" class="extype" target="_top">BoundedDouble</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countApproxDistinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countApproxDistinct(relativeSD:&lt;?&gt;):Long"></a>
      <a id="countApproxDistinct(Double):Long"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countApproxDistinct</span><span class="params">(<span name="relativeSD">relativeSD: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countApproxDistinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countApproxDistinct(p:&lt;?&gt;,sp:&lt;?&gt;):Long"></a>
      <a id="countApproxDistinct(Int,Int):Long"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countApproxDistinct</span><span class="params">(<span name="p">p: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="sp">sp: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countByValue" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countByValue()(implicitord:&lt;?&gt;):scala.collection.Map[T,Long]"></a>
      <a id="countByValue()(Ordering[T]):Map[T,Long]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countByValue</span><span class="params">()</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#countByValueApprox" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="countByValueApprox(timeout:&lt;?&gt;,confidence:&lt;?&gt;)(implicitord:&lt;?&gt;):org.apache.spark.partial.PartialResult[scala.collection.Map[T,org.apache.spark.partial.BoundedDouble]]"></a>
      <a id="countByValueApprox(Long,Double)(Ordering[T]):PartialResult[Map[T,BoundedDouble]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">countByValueApprox</span><span class="params">(<span name="timeout">timeout: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>, <span name="confidence">confidence: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <span class="extype" name="org.apache.spark.partial.PartialResult">PartialResult</span>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.partial.BoundedDouble" class="extype" target="_top">BoundedDouble</a>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#dependencies" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="dependencies:Seq[org.apache.spark.Dependency[_]]"></a>
      <a id="dependencies:Seq[Dependency[_]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">dependencies</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Dependency" class="extype" target="_top">Dependency</a>[_]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#distinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="distinct():org.apache.spark.rdd.RDD[T]"></a>
      <a id="distinct():RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">distinct</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#distinct" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="distinct(numPartitions:&lt;?&gt;)(implicitord:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="distinct(Int)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">distinct</span><span class="params">(<span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#eq" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="eq(x$1:AnyRef):Boolean"></a>
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">eq</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.AnyRef#equals" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="equals(x$1:Any):Boolean"></a>
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">equals</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.Any">Any</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#filter" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="filter(f:T=&gt;Boolean):org.apache.spark.rdd.RDD[T]"></a>
      <a id="filter((T)⇒Boolean):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">filter</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#finalize" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="finalize():Unit"></a>
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">finalize</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../java$lang.html" class="extype" name="java.lang">java.lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="symbol">classOf[java.lang.Throwable]</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#first" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="first():T"></a>
      <a id="first():T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">first</span><span class="params">()</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#firstParent" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="firstParent[U](implicitevidence$35:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="firstParent[U](ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">firstParent</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.firstParent.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.firstParent.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../org$apache$spark.html" class="extype" name="org.apache.spark">org.apache.spark</a>] </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#flatMap" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="flatMap[U](f:T=&gt;TraversableOnce[U])(implicitevidence$4:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="flatMap[U]((T)⇒TraversableOnce[U])(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">flatMap</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="scala.TraversableOnce">TraversableOnce</span>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMap.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMap.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMap.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#fold" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="fold(zeroValue:&lt;?&gt;)(op:&lt;?&gt;):T"></a>
      <a id="fold(T)((T,T)⇒T):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">fold</span><span class="params">(<span name="zeroValue">zeroValue: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>)</span><span class="params">(<span name="op">op: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#foreach" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="foreach(f:&lt;?&gt;):Unit"></a>
      <a id="foreach((T)⇒Unit):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreach</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#foreachPartition" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="foreachPartition(f:&lt;?&gt;):Unit"></a>
      <a id="foreachPartition((Iterator[T])⇒Unit):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">foreachPartition</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getCheckpointFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getCheckpointFile:Option[String]"></a>
      <a id="getCheckpointFile:Option[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getCheckpointFile</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#getClass" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getClass():Class[_]"></a>
      <a id="getClass():Class[_]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getClass</span><span class="params">()</span><span class="result">: <span class="extype" name="java.lang.Class">Class</span>[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getDependencies" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getDependencies:Seq[org.apache.spark.Dependency[_]]"></a>
      <a id="getDependencies:Seq[Dependency[_]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getDependencies</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Dependency" class="extype" target="_top">Dependency</a>[_]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getNumPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getNumPartitions:Int"></a>
      <a id="getNumPartitions:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getNumPartitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@Since</span><span class="args">(<span>
      
      <span class="symbol">&quot;1.6.0&quot;</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getPreferredLocations" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getPreferredLocations(split:&lt;?&gt;):Seq[String]"></a>
      <a id="getPreferredLocations(Partition):Seq[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getPreferredLocations</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>)</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#getStorageLevel" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getStorageLevel:org.apache.spark.storage.StorageLevel"></a>
      <a id="getStorageLevel:StorageLevel"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getStorageLevel</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.storage.StorageLevel" class="extype" target="_top">StorageLevel</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#getTermIDFs" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="getTermIDFs:Map[String,Map[String,Float]]"></a>
      <a id="getTermIDFs:Map[String,Map[String,Float]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">getTermIDFs</span><span class="result">: <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.Map">Map</span>[<span class="extype" name="scala.Predef.String">String</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Float" class="extype" target="_top">Float</a>]]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Returns the term IDFs for this SearchableRDD.</p><div class="fullcomment"><div class="comment cmt"><p>Returns the term IDFs for this SearchableRDD.
The key for the first map is the field name; the one for the second map is the term; the value is the IDF of
of the term in that field.
</p></div></div>
    </li><li name="org.apache.spark.rdd.RDD#glom" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="glom():org.apache.spark.rdd.RDD[Array[T]]"></a>
      <a id="glom():RDD[Array[T]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">glom</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#groupBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="groupBy[K&lt;:&lt;?&gt;](f:&lt;?&gt;,p:&lt;?&gt;)(implicitkt:&lt;?&gt;,implicitord:&lt;?&gt;):org.apache.spark.rdd.RDD[(K,Iterable[T])]"></a>
      <a id="groupBy[K]((T)⇒K,Partitioner)(ClassTag[K],Ordering[K]):RDD[(K,Iterable[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span></span>, <span name="p">p: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="kt">kt: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>, <span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>, <span class="extype" name="scala.Iterable">Iterable</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#groupBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="groupBy[K&lt;:&lt;?&gt;](f:&lt;?&gt;,numPartitions:&lt;?&gt;)(implicitkt:&lt;?&gt;):org.apache.spark.rdd.RDD[(K,Iterable[T])]"></a>
      <a id="groupBy[K]((T)⇒K,Int)(ClassTag[K]):RDD[(K,Iterable[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span></span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="kt">kt: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>, <span class="extype" name="scala.Iterable">Iterable</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#groupBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="groupBy[K&lt;:&lt;?&gt;](f:&lt;?&gt;)(implicitkt:&lt;?&gt;):org.apache.spark.rdd.RDD[(K,Iterable[T])]"></a>
      <a id="groupBy[K]((T)⇒K)(ClassTag[K]):RDD[(K,Iterable[T])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">groupBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="kt">kt: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.groupBy.K">K</span>, <span class="extype" name="scala.Iterable">Iterable</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>])]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#hashCode" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="hashCode():Int"></a>
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">hashCode</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#id" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="id:Int"></a>
      <a id="id:Int"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">id</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#intersection" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="intersection(other:&lt;?&gt;,numPartitions:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="intersection(RDD[T],Int):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">intersection</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#intersection" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="intersection(other:&lt;?&gt;,partitioner:&lt;?&gt;)(implicitord:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="intersection(RDD[T],Partitioner)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">intersection</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>, <span name="partitioner">partitioner: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#intersection" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="intersection(other:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="intersection(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">intersection</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#isCheckpointed" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isCheckpointed:Boolean"></a>
      <a id="isCheckpointed:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isCheckpointed</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#isEmpty" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isEmpty():Boolean"></a>
      <a id="isEmpty():Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isEmpty</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.Any#isInstanceOf" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li name="org.apache.spark.Logging#isTraceEnabled" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="isTraceEnabled():Boolean"></a>
      <a id="isTraceEnabled():Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">isTraceEnabled</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#iterator" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="iterator(split:org.apache.spark.Partition,context:org.apache.spark.TaskContext):Iterator[T]"></a>
      <a id="iterator(Partition,TaskContext):Iterator[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">iterator</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>, <span name="context">context: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.TaskContext" class="extype" target="_top">TaskContext</a></span>)</span><span class="result">: <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#keyBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="keyBy[K&lt;:&lt;?&gt;](f:&lt;?&gt;):org.apache.spark.rdd.RDD[(K,T)]"></a>
      <a id="keyBy[K]((T)⇒K):RDD[(K,T)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">keyBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.keyBy.K">K</span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="org.apache.spark.rdd.RDD.keyBy.K">K</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#lightQueryJoin" visbl="pub" data-isabs="false" fullComment="no" group="QueryJoin">
      <a id="lightQueryJoin(queryGenerator:T=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int):org.apache.spark.rdd.RDD[(T,Array[(Long,Double)])]"></a>
      <a id="lightQueryJoin((T)⇒DslQuery,Int):RDD[(T,Array[(Long,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">lightQueryJoin</span><span class="params">(<span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <a href="#lightQueryJoin[U](other:org.apache.spark.rdd.RDD[U],queryGenerator:U=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int)(implicitevidence$5:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[(U,Array[(Long,Double)])]" class="extmbr" name="it.agilelab.bigdata.spark.search.SearchableRDD#lightQueryJoin">lightQueryJoin[U](RDD[U],U=&gt;DslQuery,Int)</a>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.</p>
    </li><li name="org.apache.spark.rdd.RDD#localCheckpoint" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="localCheckpoint():RDD.this.type"></a>
      <a id="localCheckpoint():SearchableRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">localCheckpoint</span><span class="params">()</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.Logging#log" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="log:org.slf4j.Logger"></a>
      <a id="log:Logger"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">log</span><span class="result">: <span class="extype" name="org.slf4j.Logger">Logger</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logDebug" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logDebug(msg:&lt;?&gt;,throwable:&lt;?&gt;):Unit"></a>
      <a id="logDebug(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logDebug</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logDebug" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logDebug(msg:&lt;?&gt;):Unit"></a>
      <a id="logDebug(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logDebug</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logError" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logError(msg:&lt;?&gt;,throwable:&lt;?&gt;):Unit"></a>
      <a id="logError(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logError</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logError" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logError(msg:&lt;?&gt;):Unit"></a>
      <a id="logError(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logError</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logInfo" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logInfo(msg:&lt;?&gt;,throwable:&lt;?&gt;):Unit"></a>
      <a id="logInfo(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logInfo</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logInfo" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logInfo(msg:&lt;?&gt;):Unit"></a>
      <a id="logInfo(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logInfo</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logName" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logName:String"></a>
      <a id="logName:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logName</span><span class="result">: <span class="extype" name="java.lang.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logTrace" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logTrace(msg:&lt;?&gt;,throwable:&lt;?&gt;):Unit"></a>
      <a id="logTrace(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logTrace</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logTrace" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logTrace(msg:&lt;?&gt;):Unit"></a>
      <a id="logTrace(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logTrace</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logWarning" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logWarning(msg:&lt;?&gt;,throwable:&lt;?&gt;):Unit"></a>
      <a id="logWarning(⇒String,Throwable):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logWarning</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>, <span name="throwable">throwable: <span class="extype" name="scala.Throwable">Throwable</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.Logging#logWarning" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="logWarning(msg:&lt;?&gt;):Unit"></a>
      <a id="logWarning(⇒String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">logWarning</span><span class="params">(<span name="msg">msg: ⇒ <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd>Logging</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#map" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="map[U](f:T=&gt;U)(implicitevidence$3:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="map[U]((T)⇒U)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">map</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.map.U">U</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.map.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.map.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitions[U](f:Iterator[T]=&gt;Iterator[U],preservesPartitioning:Boolean)(implicitevidence$6:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitions[U]((Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mapPartitions</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitions.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitions.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitions.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitionsWithIndex" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitionsWithIndex[U](f:(Int,Iterator[T])=&gt;Iterator[U],preservesPartitioning:Boolean)(implicitevidence$8:scala.reflect.ClassTag[U]):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitionsWithIndex[U]((Int,Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">mapPartitionsWithIndex</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>, <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithIndex.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithIndex.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithIndex.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#max" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="max()(implicitord:&lt;?&gt;):T"></a>
      <a id="max()(Ordering[T]):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">max</span><span class="params">()</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#min" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="min()(implicitord:&lt;?&gt;):T"></a>
      <a id="min()(Ordering[T]):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">min</span><span class="params">()</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#name" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="name:String"></a>
      <a id="name:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">var</span>
      </span>
      <span class="symbol">
        <span class="name">name</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#ne" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="ne(x$1:AnyRef):Boolean"></a>
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">ne</span><span class="params">(<span name="arg0">arg0: <span class="extype" name="scala.AnyRef">AnyRef</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.AnyRef#notify" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="notify():Unit"></a>
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notify</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="scala.AnyRef#notifyAll" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="notifyAll():Unit"></a>
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">notifyAll</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#parent" visbl="prt" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="parent[U&lt;:&lt;?&gt;](j:&lt;?&gt;)(implicitevidence$36:&lt;?&gt;):org.apache.spark.rdd.RDD[U]"></a>
      <a id="parent[U](Int)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">parent</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="j">j: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.parent.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.parent.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a href="../../../../../org$apache$spark.html" class="extype" name="org.apache.spark">org.apache.spark</a>] </dd><dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#partitioner" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="partitioner:Option[org.apache.spark.Partitioner]"></a>
      <a id="partitioner:Option[Partitioner]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">val</span>
      </span>
      <span class="symbol">
        <span class="name">partitioner</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Option" class="extype" target="_top">Option</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#partitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="partitions:Array[org.apache.spark.Partition]"></a>
      <a id="partitions:Array[Partition]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">partitions</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#persist" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="persist():RDD.this.type"></a>
      <a id="persist():SearchableRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">persist</span><span class="params">()</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#persist" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="persist(newLevel:org.apache.spark.storage.StorageLevel):RDD.this.type"></a>
      <a id="persist(StorageLevel):SearchableRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">persist</span><span class="params">(<span name="newLevel">newLevel: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.storage.StorageLevel" class="extype" target="_top">StorageLevel</a></span>)</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#pipe" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="pipe(command:&lt;?&gt;,env:&lt;?&gt;,printPipeContext:&lt;?&gt;,printRDDElement:&lt;?&gt;,separateWorkingDir:&lt;?&gt;):org.apache.spark.rdd.RDD[String]"></a>
      <a id="pipe(Seq[String],Map[String,String],((String)⇒Unit)⇒Unit,(T,(String)⇒Unit)⇒Unit,Boolean):RDD[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">pipe</span><span class="params">(<span name="command">command: <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="scala.Predef.String">String</span>]</span>, <span name="env">env: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.String">String</span>]</span>, <span name="printPipeContext">printPipeContext: ((<span class="extype" name="scala.Predef.String">String</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>, <span name="printRDDElement">printRDDElement: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, (<span class="extype" name="scala.Predef.String">String</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>, <span name="separateWorkingDir">separateWorkingDir: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#pipe" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="pipe(command:&lt;?&gt;,env:&lt;?&gt;):org.apache.spark.rdd.RDD[String]"></a>
      <a id="pipe(String,Map[String,String]):RDD[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">pipe</span><span class="params">(<span name="command">command: <span class="extype" name="scala.Predef.String">String</span></span>, <span name="env">env: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.collection.Map" class="extype" target="_top">Map</a>[<span class="extype" name="scala.Predef.String">String</span>, <span class="extype" name="scala.Predef.String">String</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#pipe" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="pipe(command:&lt;?&gt;):org.apache.spark.rdd.RDD[String]"></a>
      <a id="pipe(String):RDD[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">pipe</span><span class="params">(<span name="command">command: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#preferredLocations" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="preferredLocations(split:&lt;?&gt;):Seq[String]"></a>
      <a id="preferredLocations(Partition):Seq[String]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">preferredLocations</span><span class="params">(<span name="split">split: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partition" class="extype" target="_top">Partition</a></span>)</span><span class="result">: <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="scala.Predef.String">String</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#queryJoin" visbl="pub" data-isabs="false" fullComment="no" group="QueryJoin">
      <a id="queryJoin(queryGenerator:T=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int):org.apache.spark.rdd.RDD[(T,Array[(T,Double)])]"></a>
      <a id="queryJoin((T)⇒DslQuery,Int):RDD[(T,Array[(T,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoin</span><span class="params">(<span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int)*">queryJoin[U](RDD[U],U=&gt;DslQuery,Int)</span>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.</p>
    </li><li name="it.agilelab.bigdata.spark.search.SearchableRDD#queryJoinWithResultsTransformer" visbl="pub" data-isabs="false" fullComment="no" group="QueryJoin">
      <a id="queryJoinWithResultsTransformer[V](queryGenerator:T=&gt;it.agilelab.bigdata.spark.search.dsl.DslQuery,maxHits:Int,resultsTransformer:T=&gt;V)(implicitevidence$2:scala.reflect.ClassTag[V]):org.apache.spark.rdd.RDD[(T,Array[(V,Double)])]"></a>
      <a id="queryJoinWithResultsTransformer[V]((T)⇒DslQuery,Int,(T)⇒V)(ClassTag[V]):RDD[(T,Array[(V,Double)])]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">queryJoinWithResultsTransformer</span><span class="tparams">[<span name="V">V</span>]</span><span class="params">(<span name="queryGenerator">queryGenerator: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <a href="dsl/DslQuery.html" class="extype" name="it.agilelab.bigdata.spark.search.dsl.DslQuery">DslQuery</a></span>, <span name="maxHits">maxHits: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="resultsTransformer">resultsTransformer: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.queryJoinWithResultsTransformer.V">V</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>)])]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Like <span class="extype" name="queryJoinWithResultsTransformer[U,V](other:org\.apache\.spark\.rdd\.RDD[U],queryGenerator:U=&gt;it\.agilelab\.bigdata\.spark\.search\.dsl\.DslQuery,maxHits:Int,transformer:T=&gt;V)*">queryJoin[U,V](RDD[U],U=&gt;DslQuery,Int,T=&gt;V)</span>,
but with <code>this</code> as the <code>other</code> RDD; that is, a query self join.</p>
    </li><li name="org.apache.spark.rdd.RDD#randomSplit" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="randomSplit(weights:&lt;?&gt;,seed:&lt;?&gt;):Array[org.apache.spark.rdd.RDD[T]]"></a>
      <a id="randomSplit(Array[Double],Long):Array[RDD[T]]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">randomSplit</span><span class="params">(<span name="weights">weights: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a>]</span>, <span name="seed">seed: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#reduce" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="reduce(f:&lt;?&gt;):T"></a>
      <a id="reduce((T,T)⇒T):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">reduce</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#repartition" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="repartition(numPartitions:&lt;?&gt;)(implicitord:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="repartition(Int)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">repartition</span><span class="params">(<span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#sample" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="sample(withReplacement:&lt;?&gt;,fraction:&lt;?&gt;,seed:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="sample(Boolean,Double,Long):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sample</span><span class="params">(<span name="withReplacement">withReplacement: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>, <span name="fraction">fraction: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Double" class="extype" target="_top">Double</a></span>, <span name="seed">seed: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#saveAsObjectFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="saveAsObjectFile(path:String):Unit"></a>
      <a id="saveAsObjectFile(String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">saveAsObjectFile</span><span class="params">(<span name="path">path: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#saveAsTextFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="saveAsTextFile(path:&lt;?&gt;,codec:&lt;?&gt;):Unit"></a>
      <a id="saveAsTextFile(String,Class[_&lt;:CompressionCodec]):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">saveAsTextFile</span><span class="params">(<span name="path">path: <span class="extype" name="scala.Predef.String">String</span></span>, <span name="codec">codec: <span class="extype" name="scala.Predef.Class">Class</span>[_ &lt;: <span class="extype" name="org.apache.hadoop.io.compress.CompressionCodec">CompressionCodec</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#saveAsTextFile" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="saveAsTextFile(path:&lt;?&gt;):Unit"></a>
      <a id="saveAsTextFile(String):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">saveAsTextFile</span><span class="params">(<span name="path">path: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#setName" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="setName(_name:String):RDD.this.type"></a>
      <a id="setName(String):SearchableRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">setName</span><span class="params">(<span name="_name">_name: <span class="extype" name="scala.Predef.String">String</span></span>)</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#sortBy" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="sortBy[K](f:T=&gt;K,ascending:Boolean,numPartitions:Int)(implicitord:Ordering[K],implicitctag:scala.reflect.ClassTag[K]):org.apache.spark.rdd.RDD[T]"></a>
      <a id="sortBy[K]((T)⇒K,Boolean,Int)(Ordering[K],ClassTag[K]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sortBy</span><span class="tparams">[<span name="K">K</span>]</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.sortBy.K">K</span></span>, <span name="ascending">ascending: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="org.apache.spark.rdd.RDD.sortBy.K">K</span>]</span>, <span name="ctag">ctag: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.sortBy.K">K</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#sparkContext" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="sparkContext:org.apache.spark.SparkContext"></a>
      <a id="sparkContext:SparkContext"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">sparkContext</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.SparkContext" class="extype" target="_top">SparkContext</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#subtract" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="subtract(other:&lt;?&gt;,p:&lt;?&gt;)(implicitord:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="subtract(RDD[T],Partitioner)(Ordering[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">subtract</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>, <span name="p">p: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Partitioner" class="extype" target="_top">Partitioner</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#subtract" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="subtract(other:&lt;?&gt;,numPartitions:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="subtract(RDD[T],Int):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">subtract</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>, <span name="numPartitions">numPartitions: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#subtract" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="subtract(other:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="subtract(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">subtract</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#synchronized" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="synchronized[T0](x$1:=&gt;T0):T0"></a>
      <a id="synchronized[T0](⇒T0):T0"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">synchronized</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="params">(<span name="arg0">arg0: ⇒ <span class="extype" name="java.lang.AnyRef.synchronized.T0">T0</span></span>)</span><span class="result">: <span class="extype" name="java.lang.AnyRef.synchronized.T0">T0</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#take" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="take(num:Int):Array[T]"></a>
      <a id="take(Int):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">take</span><span class="params">(<span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#takeOrdered" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="takeOrdered(num:&lt;?&gt;)(implicitord:&lt;?&gt;):Array[T]"></a>
      <a id="takeOrdered(Int)(Ordering[T]):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeOrdered</span><span class="params">(<span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#takeSample" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="takeSample(withReplacement:&lt;?&gt;,num:&lt;?&gt;,seed:&lt;?&gt;):Array[T]"></a>
      <a id="takeSample(Boolean,Int,Long):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">takeSample</span><span class="params">(<span name="withReplacement">withReplacement: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>, <span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>, <span name="seed">seed: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toDebugString" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toDebugString:String"></a>
      <a id="toDebugString:String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toDebugString</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toJavaRDD" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toJavaRDD():org.apache.spark.api.java.JavaRDD[T]"></a>
      <a id="toJavaRDD():JavaRDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toJavaRDD</span><span class="params">()</span><span class="result">: <span class="extype" name="org.apache.spark.api.java.JavaRDD">JavaRDD</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toLocalIterator" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toLocalIterator:Iterator[T]"></a>
      <a id="toLocalIterator:Iterator[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toLocalIterator</span><span class="result">: <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toString" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toString():String"></a>
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">toString</span><span class="params">()</span><span class="result">: <span class="extype" name="scala.Predef.String">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD → AnyRef → Any</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#top" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="top(num:&lt;?&gt;)(implicitord:&lt;?&gt;):Array[T]"></a>
      <a id="top(Int)(Ordering[T]):Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">top</span><span class="params">(<span name="num">num: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="ord">ord: <span class="extype" name="scala.Ordering">Ordering</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#treeAggregate" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="treeAggregate[U](zeroValue:U)(seqOp:(U,T)=&gt;U,combOp:(U,U)=&gt;U,depth:Int)(implicitevidence$34:scala.reflect.ClassTag[U]):U"></a>
      <a id="treeAggregate[U](U)((U,T)⇒U,(U,U)⇒U,Int)(ClassTag[U]):U"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">treeAggregate</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="zeroValue">zeroValue: <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>)</span><span class="params">(<span name="seqOp">seqOp: (<span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>, <span name="combOp">combOp: (<span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>, <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>, <span name="depth">depth: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span>]</span>)</span><span class="result">: <span class="extype" name="org.apache.spark.rdd.RDD.treeAggregate.U">U</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#treeReduce" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="treeReduce(f:(T,T)=&gt;T,depth:Int):T"></a>
      <a id="treeReduce((T,T)⇒T,Int):T"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">treeReduce</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>) ⇒ <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>, <span name="depth">depth: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#union" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="union(other:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="union(RDD[T]):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">union</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#unpersist" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="unpersist(blocking:Boolean):RDD.this.type"></a>
      <a id="unpersist(Boolean):SearchableRDD.this.type"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">unpersist</span><span class="params">(<span name="blocking">blocking: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="" class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD">SearchableRDD</a>.this.type</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="scala.AnyRef#wait" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="wait():Unit"></a>
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.InterruptedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="scala.AnyRef#wait" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="wait(x$1:Long,x$2:Int):Unit"></a>
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.InterruptedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="scala.AnyRef#wait" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="wait(x$1:Long):Unit"></a>
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier">final </span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">(<span>
      
      <span class="defval" name="classOf[java.lang.InterruptedException]">...</span>
    </span>)</span>
              
        </dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zip" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zip[U&lt;:&lt;?&gt;](other:&lt;?&gt;)(implicitevidence$13:&lt;?&gt;):org.apache.spark.rdd.RDD[(T,U)]"></a>
      <a id="zip[U](RDD[U])(ClassTag[U]):RDD[(T,U)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zip</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="other">other: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zip.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zip.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.zip.U">U</span>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B&lt;:&lt;?&gt;,C&lt;:&lt;?&gt;,D&lt;:&lt;?&gt;,V&lt;:&lt;?&gt;](rdd2:&lt;?&gt;,rdd3:&lt;?&gt;,rdd4:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$28:&lt;?&gt;,implicitevidence$29:&lt;?&gt;,implicitevidence$30:&lt;?&gt;,implicitevidence$31:&lt;?&gt;):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,D,V](RDD[B],RDD[C],RDD[D])((Iterator[T],Iterator[B],Iterator[C],Iterator[D])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[D],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="D">D</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="rdd4">rdd4: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>, <span name="arg3">arg3: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B&lt;:&lt;?&gt;,C&lt;:&lt;?&gt;,D&lt;:&lt;?&gt;,V&lt;:&lt;?&gt;](rdd2:&lt;?&gt;,rdd3:&lt;?&gt;,rdd4:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$24:&lt;?&gt;,implicitevidence$25:&lt;?&gt;,implicitevidence$26:&lt;?&gt;,implicitevidence$27:&lt;?&gt;):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,D,V](RDD[B],RDD[C],RDD[D],Boolean)((Iterator[T],Iterator[B],Iterator[C],Iterator[D])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[D],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="D">D</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="rdd4">rdd4: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.D">D</span>]</span>, <span name="arg3">arg3: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B&lt;:&lt;?&gt;,C&lt;:&lt;?&gt;,V&lt;:&lt;?&gt;](rdd2:&lt;?&gt;,rdd3:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$21:&lt;?&gt;,implicitevidence$22:&lt;?&gt;,implicitevidence$23:&lt;?&gt;):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,V](RDD[B],RDD[C])((Iterator[T],Iterator[B],Iterator[C])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B&lt;:&lt;?&gt;,C&lt;:&lt;?&gt;,V&lt;:&lt;?&gt;](rdd2:&lt;?&gt;,rdd3:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$18:&lt;?&gt;,implicitevidence$19:&lt;?&gt;,implicitevidence$20:&lt;?&gt;):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,C,V](RDD[B],RDD[C],Boolean)((Iterator[T],Iterator[B],Iterator[C])⇒Iterator[V])(ClassTag[B],ClassTag[C],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="C">C</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="rdd3">rdd3: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.C">C</span>]</span>, <span name="arg2">arg2: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B&lt;:&lt;?&gt;,V&lt;:&lt;?&gt;](rdd2:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$16:&lt;?&gt;,implicitevidence$17:&lt;?&gt;):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,V](RDD[B])((Iterator[T],Iterator[B])⇒Iterator[V])(ClassTag[B],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipPartitions" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipPartitions[B&lt;:&lt;?&gt;,V&lt;:&lt;?&gt;](rdd2:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$14:&lt;?&gt;,implicitevidence$15:&lt;?&gt;):org.apache.spark.rdd.RDD[V]"></a>
      <a id="zipPartitions[B,V](RDD[B],Boolean)((Iterator[T],Iterator[B])⇒Iterator[V])(ClassTag[B],ClassTag[V]):RDD[V]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipPartitions</span><span class="tparams">[<span name="B">B</span>, <span name="V">V</span>]</span><span class="params">(<span name="rdd2">rdd2: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>], <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.B">B</span>]</span>, <span name="arg1">arg1: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.zipPartitions.V">V</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipWithIndex" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipWithIndex():org.apache.spark.rdd.RDD[(T,Long)]"></a>
      <a id="zipWithIndex():RDD[(T,Long)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipWithIndex</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#zipWithUniqueId" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="zipWithUniqueId():org.apache.spark.rdd.RDD[(T,Long)]"></a>
      <a id="zipWithUniqueId():RDD[(T,Long)]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name">zipWithUniqueId</span><span class="params">()</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[(<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Long" class="extype" target="_top">Long</a>)]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd></dl></div>
    </li></ol>
            </div>

        

        <div id="values" class="values members">
              <h3>Deprecated Value Members</h3>
              <ol><li name="org.apache.spark.rdd.RDD#filterWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="filterWith[A&lt;:&lt;?&gt;](constructA:&lt;?&gt;)(p:&lt;?&gt;):org.apache.spark.rdd.RDD[T]"></a>
      <a id="filterWith[A]((Int)⇒A)((T,A)⇒Boolean):RDD[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex and filter">filterWith</span><span class="tparams">[<span name="A">A</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.filterWith.A">A</span></span>)</span><span class="params">(<span name="p">p: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.filterWith.A">A</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex and filter</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#flatMapWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="flatMapWith[A&lt;:&lt;?&gt;,U&lt;:&lt;?&gt;](constructA:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$12:&lt;?&gt;):org.apache.spark.rdd.RDD[U]"></a>
      <a id="flatMapWith[A,U]((Int)⇒A,Boolean)((T,A)⇒Seq[U])(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex and flatMap">flatMapWith</span><span class="tparams">[<span name="A">A</span>, <span name="U">U</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.A">A</span></span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.A">A</span>) ⇒ <span class="extype" name="scala.Seq">Seq</span>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.U">U</span>]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.flatMapWith.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex and flatMap</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#foreachWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="foreachWith[A&lt;:&lt;?&gt;](constructA:&lt;?&gt;)(f:&lt;?&gt;):Unit"></a>
      <a id="foreachWith[A]((Int)⇒A)((T,A)⇒Unit):Unit"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex and foreach">foreachWith</span><span class="tparams">[<span name="A">A</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.foreachWith.A">A</span></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.foreachWith.A">A</span>) ⇒ <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>)</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Unit" class="extype" target="_top">Unit</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex and foreach</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitionsWithContext" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitionsWithContext[U&lt;:&lt;?&gt;](f:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(implicitevidence$9:&lt;?&gt;):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitionsWithContext[U]((TaskContext,Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.2.0) use TaskContext.get">mapPartitionsWithContext</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.TaskContext" class="extype" target="_top">TaskContext</a>, <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithContext.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithContext.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithContext.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@DeveloperApi</span><span class="args">()</span>
              
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.2.0)</i> use TaskContext.get</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapPartitionsWithSplit" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapPartitionsWithSplit[U&lt;:&lt;?&gt;](f:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(implicitevidence$10:&lt;?&gt;):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapPartitionsWithSplit[U]((Int,Iterator[T])⇒Iterator[U],Boolean)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 0.7.0) use mapPartitionsWithIndex">mapPartitionsWithSplit</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>, <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]) ⇒ <span class="extype" name="scala.Iterator">Iterator</span>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithSplit.U">U</span>]</span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithSplit.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapPartitionsWithSplit.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 0.7.0)</i> use mapPartitionsWithIndex</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#mapWith" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="mapWith[A&lt;:&lt;?&gt;,U&lt;:&lt;?&gt;](constructA:&lt;?&gt;,preservesPartitioning:&lt;?&gt;)(f:&lt;?&gt;)(implicitevidence$11:&lt;?&gt;):org.apache.spark.rdd.RDD[U]"></a>
      <a id="mapWith[A,U]((Int)⇒A,Boolean)((T,A)⇒U)(ClassTag[U]):RDD[U]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use mapPartitionsWithIndex">mapWith</span><span class="tparams">[<span name="A">A</span>, <span name="U">U</span>]</span><span class="params">(<span name="constructA">constructA: (<a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Int" class="extype" target="_top">Int</a>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.mapWith.A">A</span></span>, <span name="preservesPartitioning">preservesPartitioning: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Boolean" class="extype" target="_top">Boolean</a></span>)</span><span class="params">(<span name="f">f: (<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>, <span class="extype" name="org.apache.spark.rdd.RDD.mapWith.A">A</span>) ⇒ <span class="extype" name="org.apache.spark.rdd.RDD.mapWith.U">U</span></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.reflect.ClassTag" class="extype" target="_top">ClassTag</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapWith.U">U</span>]</span>)</span><span class="result">: <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="org.apache.spark.rdd.RDD.mapWith.U">U</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use mapPartitionsWithIndex</p></dd></dl></div>
    </li><li name="org.apache.spark.rdd.RDD#toArray" visbl="pub" data-isabs="false" fullComment="yes" group="Ungrouped">
      <a id="toArray():Array[T]"></a>
      <a id="toArray():Array[T]"></a>
      <h4 class="signature">
      <span class="modifier_kind">
        <span class="modifier"></span>
        <span class="kind">def</span>
      </span>
      <span class="symbol">
        <span class="name deprecated" title="Deprecated: (Since version 1.0.0) use collect">toArray</span><span class="params">()</span><span class="result">: <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Array" class="extype" target="_top">Array</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>RDD</dd><dt>Annotations</dt><dd>
                <span class="name">@deprecated</span>
              
        </dd><dt>Deprecated</dt><dd class="cmt"><p><i>(Since version 1.0.0)</i> use collect</p></dd></dl></div>
    </li></ol>
            </div>
        </div>

        <div id="inheritedMembers">
        <div class="parent" name="org.apache.spark.rdd.RDD">
              <h3>Inherited from <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.rdd.RDD" class="extype" target="_top">RDD</a>[<span class="extype" name="it.agilelab.bigdata.spark.search.SearchableRDD.T">T</span>]</h3>
            </div><div class="parent" name="org.apache.spark.Logging">
              <h3>Inherited from <a href="http://spark.apache.org/docs/1.6.2/api/scala/index.html#org.apache.spark.Logging" class="extype" target="_top">Logging</a></h3>
            </div><div class="parent" name="scala.Serializable">
              <h3>Inherited from <a href="http://www.scala-lang.org/api/2.10.6/index.html#scala.Serializable" class="extype" target="_top">Serializable</a></h3>
            </div><div class="parent" name="java.io.Serializable">
              <h3>Inherited from <span class="extype" name="java.io.Serializable">Serializable</span></h3>
            </div><div class="parent" name="scala.AnyRef">
              <h3>Inherited from <span class="extype" name="scala.AnyRef">AnyRef</span></h3>
            </div><div class="parent" name="scala.Any">
              <h3>Inherited from <span class="extype" name="scala.Any">Any</span></h3>
            </div>
        
        </div>

        <div id="groupedMembers">
        <div class="group" name="QueryJoin">
              <h3>QueryJoin</h3>
              
            </div><div class="group" name="Search">
              <h3>Search</h3>
              
            </div><div class="group" name="Ungrouped">
              <h3>Ungrouped</h3>
              
            </div>
        </div>

      </div>

      <div id="tooltip"></div>

      <div id="footer">  </div>
      <script defer="defer" type="text/javascript" id="jquery-js" src="../../../../../lib/jquery.js"></script><script defer="defer" type="text/javascript" id="jquery-ui-js" src="../../../../../lib/jquery-ui.js"></script><script defer="defer" type="text/javascript" id="tools-tooltip-js" src="../../../../../lib/tools.tooltip.js"></script><script defer="defer" type="text/javascript" id="template-js" src="../../../../../lib/template.js"></script>
    </body>
      </html>